/*
 * Created on 07-May-2004
 * Created by Paul Gardner
 * Copyright (C) Azureus Software, Inc, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

package org.gudy.azureus2.pluginsimpl.local.update;

/**
 * @author parg
 *
 */

import java.io.InputStream;
import java.util.Iterator;

import org.gudy.azureus2.core3.util.Debug;
import org.gudy.azureus2.plugins.update.Update;
import org.gudy.azureus2.plugins.update.UpdateCheckInstance;
import org.gudy.azureus2.plugins.update.UpdateException;
import org.gudy.azureus2.plugins.update.UpdateListener;
import org.gudy.azureus2.plugins.utils.resourcedownloader.ResourceDownloader;

import com.aelitis.azureus.core.util.CopyOnWriteList;

public class UpdateImpl implements Update {
    private UpdateCheckInstanceImpl instance;
    private UpdatableComponentImpl component;
    private String name;
    private String[] description;
    private String relative_url_base = "";
    private String new_version;
    private ResourceDownloader[] downloaders;
    private boolean mandatory;
    private int restart_required;
    private String description_url;

    private Object user_object;

    private CopyOnWriteList listeners = new CopyOnWriteList();
    private volatile boolean cancelled;
    private volatile boolean complete;
    private volatile boolean succeeded;

    protected UpdateImpl(UpdateCheckInstanceImpl _instance, UpdatableComponentImpl _component, String _name, String[] _desc, String _new_version,
            ResourceDownloader[] _downloaders, boolean _mandatory, int _restart_required) {
        instance = _instance;
        component = _component;
        name = _name;
        description = _desc;
        new_version = _new_version;
        downloaders = _downloaders;
        mandatory = _mandatory;
        restart_required = _restart_required;

        /*
         * System.out.println( "Update:" + name + "/" + new_version + ", mand=" + mandatory + ", restart = " + restart_required ); for (int
         * i=0;i<description.length;i++){ System.out.println( description[i]); } for (int i=0;i<downloaders.length;i++){ try{ System.out.println(
         * "  size:" + downloaders[i].getSize()); }catch( Throwable e ){ e.printStackTrace(); } }
         */
    }

    public UpdateCheckInstance getCheckInstance() {
        return (instance);
    }

    protected UpdatableComponentImpl getComponent() {
        return (component);
    }

    public String getName() {
        return (name);
    }

    public String[] getDescription() {
        return (description);
    }

    public String getRelativeURLBase() {
        return (relative_url_base);
    }

    public void setRelativeURLBase(String base) {
        relative_url_base = base;
    }

    // @see org.gudy.azureus2.plugins.update.Update#getDesciptionURL()
    public String getDesciptionURL() {
        return description_url;
    }

    // @see org.gudy.azureus2.plugins.update.Update#setDescriptionURL(java.lang.String)
    public void setDescriptionURL(String url) {
        description_url = url;
    }

    public String getNewVersion() {
        return (new_version);
    }

    public ResourceDownloader[] getDownloaders() {
        return (downloaders);
    }

    public boolean isMandatory() {
        return (mandatory);
    }

    public void setRestartRequired(int _restart_required) {
        restart_required = _restart_required;
    }

    public int getRestartRequired() {
        return (restart_required);
    }

    public void setUserObject(Object obj) {
        user_object = obj;
    }

    public Object getUserObject() {
        return (user_object);
    }

    public void cancel() {
        cancelled = true;

        for (int i = 0; i < downloaders.length; i++) {

            try {
                downloaders[i].cancel();

            } catch (Throwable e) {

                Debug.printStackTrace(e);
            }
        }

        Iterator it = listeners.iterator();

        while (it.hasNext()) {

            try {
                ((UpdateListener) it.next()).cancelled(this);

            } catch (Throwable e) {

                Debug.printStackTrace(e);
            }
        }
    }

    public void complete(boolean success) {
        complete = true;
        succeeded = success;

        Iterator it = listeners.iterator();

        for (int i = 0; i < listeners.size(); i++) {

            try {
                ((UpdateListener) it.next()).complete(this);

            } catch (Throwable e) {

                Debug.printStackTrace(e);
            }
        }
    }

    public boolean isCancelled() {
        return (cancelled);
    }

    public boolean isComplete() {
        return (complete);
    }

    public boolean wasSuccessful() {
        return (succeeded);
    }

    public Object getDecision(int decision_type, String decision_name, String decision_description, Object decision_data) {
        return (instance.getDecision(this, decision_type, decision_name, decision_description, decision_data));
    }

    public InputStream verifyData(InputStream is, boolean force)

    throws UpdateException {
        return (((UpdateManagerImpl) instance.getManager()).verifyData(this, is, force));
    }

    public void addListener(UpdateListener l) {
        listeners.add(l);

        if (cancelled) {

            l.cancelled(this);

        } else if (complete) {

            l.complete(this);
        }
    }

    public void removeListener(UpdateListener l) {
        listeners.remove(l);
    }
}
